San Francisco Fire Data - Plotly Experimentation¶
SF Fire Data (Incidents, Violations, and more)
Messing around with plotly visualization and ipywidgets
In [24]:
import os
import pandas as pd
import numpy as np
import re
import ipywidgets as widgets
import matplotlib.pyplot as plt
import seaborn as sns
from pylab import rcParams
%matplotlib inline
pd.options.display.max_columns = 40
sns.set(style='darkgrid', font_scale=1.5)
rcParams['figure.figsize'] = 14, 8
EDA¶
In [11]:
data = pd.read_csv('../../../data/sf-fires-data/fire-department-calls-for-service.csv',
low_memory=False)
In [12]:
data.columns = [i.lower().replace(' ', '_') for i in data.columns]
In [13]:
for i in data.columns:
if 'date' in i or 'dttm' in i:
print(i)
data[i] = pd.to_datetime(data[i])
In [14]:
data.shape
Out[14]:
In [15]:
data.head()
Out[15]:
In [16]:
pd.DataFrame(np.transpose([data.dtypes.values, data.isnull().sum().values]),
index=data.columns, columns=['dtype', 'isnull'])
Out[16]:
In [17]:
data.describe(include='all')
Out[17]:
Call Type¶
In [18]:
call_types = data[['call_number', 'call_type']].drop_duplicates()
In [19]:
# check to see if each call number is only associated with ONE call type
call_types.call_number.value_counts()[0:5]
Out[19]:
In [20]:
call_types.call_type.value_counts()
Out[20]:
In [25]:
call_types.call_type.value_counts().plot(kind='bar')
plt.title('Distribution of Call Types')
plt.ylabel('Number of Calls')
plt.xlabel('Call Type')
plt.yscale('log')
Time of Year¶
In [26]:
call_dates = data[['call_number', 'call_date']].drop_duplicates()
In [27]:
call_dates.call_number.value_counts()[0:5]
Out[27]:
In [28]:
month_map = {
1: 'January',
2: 'February',
3: 'March',
4: 'April',
5: 'May',
6: 'June',
7: 'July',
8: 'August',
9: 'September',
10: 'October',
11: 'November',
12: 'December'
}
In [29]:
call_dates['month'] = call_dates.call_date.dt.month.map(month_map)
In [30]:
fig1 = pd.DataFrame(call_dates.month.value_counts()).loc[list((map(month_map.get, range(1, 13))))]
plt.plot(fig1.index, fig1.month)
plt.title('Distribution of Incidents Throughout the Year')
plt.ylabel('Number of Calls')
plt.xlabel('Month')
plt.xticks(rotation=90)
plt.show()
In [31]:
# calls per month, year
In [32]:
calls_per_month = call_dates['call_date'].groupby([call_dates.call_date.dt.year, call_dates.call_date.dt.month]
).agg('count').to_frame()
calls_per_month['date'] = calls_per_month.index
calls_per_month.date = pd.to_datetime(calls_per_month.date, format='(%Y, %m)')
calls_per_month = calls_per_month.reset_index(drop=True)
calls_per_month.columns = ['num_calls', 'month']
In [33]:
calls_per_month.head()
Out[33]:
In [34]:
# import plotly
import plotly.plotly as py
import plotly.graph_objs as go
# these two lines are what allow your code to show up in a notebook!
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode()
mapbox_access_token = 'pk.eyJ1IjoidGtoNTA0NCIsImEiOiJjanB1MnppNHowY2h4NDhxem1wYzQ0YnNvIn0.nVJ3ydUD6wePxdrWL8dvqA'
In [35]:
# sepcify that we want a scatter plot with, with date on the x axis and meet on the y axis
fig_data = [go.Scatter(x=calls_per_month.month,
y=calls_per_month.num_calls)]
# specify the layout of our figure
layout = go.Layout(title = "Number of Calls per Month",
xaxis = dict(title='Date',
ticklen=5,
zeroline=False))
# create and show our figure
fig = dict(data = fig_data,
layout = layout)
iplot(fig)
Location¶
In [36]:
data.head()
Out[36]:
In [37]:
call_loc = data[['call_number', 'call_type', 'call_date', 'address', 'zipcode_of_incident', 'location']].drop_duplicates()
In [38]:
call_loc.shape
Out[38]:
In [39]:
call_loc.dtypes
Out[39]:
In [40]:
call_loc.isnull().sum()
Out[40]:
In [41]:
call_loc['text'] = 'Date: ' + call_loc.call_date.astype(str) + ', Address: ' + call_loc.address.astype(str) + ', Zip: ' + call_loc.zipcode_of_incident.fillna(0).astype(int).astype(str).replace('0', '')
In [42]:
call_loc.head()
Out[42]:
In [43]:
lat = []
lon = []
for i in call_loc.location:
spl = i.split()
if 'latitude' in spl[2]:
lat.append(re.search(r'\d+.\d+', spl[3]).group())
else:
lat.append(np.nan)
if 'longitude' in spl[4]:
lon.append(re.search(r'\d+.\d+', spl[5]).group())
else:
lon.append(np.nan)
In [44]:
assert len(call_loc) == len(lat)
assert len(call_loc) == len(lon)
In [45]:
call_loc['latitude'] = lat
call_loc['longitude'] = lon
In [46]:
call_loc.isnull().sum()
Out[46]:
In [47]:
call_loc.dtypes
Out[47]:
In [48]:
call_loc.latitude = call_loc.latitude.astype(float)
call_loc.longitude = call_loc.longitude.astype(float) * -1
In [49]:
print('Latitude:')
print('min: ', min(call_loc.latitude.tolist()))
print('max: ', max(call_loc.latitude.tolist()))
print('mean:', np.mean(call_loc.latitude.tolist()))
print()
print('Longitude:')
print('min: ', min(call_loc.longitude.tolist()))
print('mean:', np.mean(call_loc.longitude.tolist()))
print('max: ', max(call_loc.longitude.tolist()))
In [50]:
# plot
# there are a lot of data points - lets filter on year and call_type
In [51]:
yr = widgets.IntSlider(
min=min(call_loc.call_date.dt.year),
max=max(call_loc.call_date.dt.year),
step=1,
description='Year:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='d'
)
In [52]:
ct = widgets.Dropdown(
options=call_loc.call_type.unique().tolist(),
description='Call Type:',
disabled=False,
)
In [53]:
print('Choose parameters to visualize:')
In [54]:
display(yr)
In [55]:
display(ct)
In [56]:
print('Number of data points to plot based on parameters:',
len(call_loc[(call_loc.call_date.dt.year == yr.value) & (call_loc.call_type == ct.value)]))
In [57]:
# specify data
loc_data = call_loc[(call_loc.call_date.dt.year == yr.value) &
(call_loc.call_type == ct.value)]
# specify what we want our map to look like
fig_data = [
go.Scattermapbox(
lat=loc_data.latitude,
lon=loc_data.longitude,
mode='markers',
marker=dict(size=9),
text=loc_data.text,
)
]
# chart information
layout = go.Layout(
autosize=True,
hovermode='closest',
mapbox=dict(
accesstoken=mapbox_access_token,
bearing=0,
center=dict(
lat=37.75,
lon=-122.42
),
pitch=0,
zoom=10
),
)
# actually show our figure
fig = dict(data=fig_data,
layout=layout)
iplot(fig)
Response time¶
- Call Date: Date the call is received at the 911 Dispatch Center. Used for reporting purposes.
- Watch Date: Watch date when the call is received. Watch date starts at 0800 each morning and ends at 0800 the next day.
- Received DtTm: Date and time of call is received at the 911 Dispatch Center.
- Entry DtTm: Date and time the 911 operator submits the entry of the initical call information into the CAD system
- Dispatch DtTm: Date and time the 911 operator dispatches this unit to the call.
- Response DtTm: Date and time this unit acknowledges the dispatch and records that the unit is en route to the location of the call.
- On Scene DtTm: Date and time the unit records arriving to the location of the incident
- Transport DtTm: If this unit is an ambulance, date and time the unit begins the transport to hospital
- Hospital DtTm: If this unit is an ambulance, date and time the unit arrives to the hospital.
- Available DtTm: Date and time this unit is no longer assigned to this call and it is available for another dispatch.
In [58]:
data.head()
Out[58]:
In [61]:
# for i in data.call_number.unique():
# if len(data[data.call_number == i]) == 10:
In [62]:
call_num = pd.DataFrame(data.call_number.value_counts())
In [63]:
call_num[call_num['call_number'] == 10]
Out[63]:
In [64]:
data[data.call_number == 100650261]
Out[64]:
In [65]:
# priority - Code 2: Non-Emergency or Code 3: Emergency
data.final_priority.value_counts()
Out[65]:
In [66]:
data['response_time'] = data.response_dttm - data.dispatch_dttm
In [67]:
data.head()
Out[67]:
In [68]:
# average response times for each unit
In [69]:
data.unit_id.nunique()
Out[69]:
In [70]:
resp_times = data[data.response_time.notnull()][['unit_id', 'response_time']]
In [71]:
resp_times.response_time = resp_times.response_time.dt.seconds
In [72]:
resp_times.groupby('unit_id').mean().sort_values('response_time')
Out[72]: